<!DOCTYPE html>
<html>
<!-- Created by GNU Texinfo 7.1.1, https://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<!-- This file documents the use of the GNU compilers.

Copyright © 1988-2023 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Funding Free Software", the Front-Cover
Texts being (a) (see below), and with the Back-Cover Texts being (b)
(see below).  A copy of the license is included in the section entitled
"GNU Free Documentation License".

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU
     software.  Copies published by the Free Software Foundation raise
     funds for GNU development. -->
<title>Compound Literals (Using the GNU Compiler Collection (GCC))</title>

<meta name="description" content="Compound Literals (Using the GNU Compiler Collection (GCC))">
<meta name="keywords" content="Compound Literals (Using the GNU Compiler Collection (GCC))">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta name="viewport" content="width=device-width,initial-scale=1">

<link href="index.html" rel="start" title="Top">
<link href="Indices.html" rel="index" title="Indices">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="C-Extensions.html" rel="up" title="C Extensions">
<link href="Designated-Inits.html" rel="next" title="Designated Inits">
<link href="Initializers.html" rel="prev" title="Initializers">
<style type="text/css">
<!--
a.copiable-link {visibility: hidden; text-decoration: none; line-height: 0em}
div.example {margin-left: 3.2em}
kbd.key {font-style: normal}
span:hover a.copiable-link {visibility: visible}
-->
</style>


</head>

<body lang="en_US">
<div class="section-level-extent" id="Compound-Literals">
<div class="nav-panel">
<p>
Next: <a href="Designated-Inits.html" accesskey="n" rel="next">Designated Initializers</a>, Previous: <a href="Initializers.html" accesskey="p" rel="prev">Non-Constant Initializers</a>, Up: <a href="C-Extensions.html" accesskey="u" rel="up">Extensions to the C Language Family</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Indices.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<h3 class="section" id="Compound-Literals-1"><span>6.28 Compound Literals<a class="copiable-link" href="#Compound-Literals-1"> &para;</a></span></h3>
<a class="index-entry-id" id="index-constructor-expressions"></a>
<a class="index-entry-id" id="index-initializations-in-expressions"></a>
<a class="index-entry-id" id="index-structures_002c-constructor-expression"></a>
<a class="index-entry-id" id="index-expressions_002c-constructor"></a>
<a class="index-entry-id" id="index-compound-literals"></a>

<p>A compound literal looks like a cast of a brace-enclosed aggregate
initializer list.  Its value is an object of the type specified in
the cast, containing the elements specified in the initializer.
Unlike the result of a cast, a compound literal is an lvalue.  ISO
C99 and later support compound literals.  As an extension, GCC
supports compound literals also in C90 mode and in C++, although
as explained below, the C++ semantics are somewhat different.
</p>
<p>Usually, the specified type of a compound literal is a structure.  Assume
that <code class="code">struct foo</code> and <code class="code">structure</code> are declared as shown:
</p>
<div class="example smallexample">
<pre class="example-preformatted">struct foo {int a; char b[2];} structure;
</pre></div>

<p>Here is an example of constructing a <code class="code">struct foo</code> with a compound literal:
</p>
<div class="example smallexample">
<pre class="example-preformatted">structure = ((struct foo) {x + y, 'a', 0});
</pre></div>

<p>This is equivalent to writing the following:
</p>
<div class="example smallexample">
<pre class="example-preformatted">{
  struct foo temp = {x + y, 'a', 0};
  structure = temp;
}
</pre></div>

<p>You can also construct an array, though this is dangerous in C++, as
explained below.  If all the elements of the compound literal are
(made up of) simple constant expressions suitable for use in
initializers of objects of static storage duration, then the compound
literal can be coerced to a pointer to its first element and used in
such an initializer, as shown here:
</p>
<div class="example smallexample">
<pre class="example-preformatted">char **foo = (char *[]) { &quot;x&quot;, &quot;y&quot;, &quot;z&quot; };
</pre></div>

<p>Compound literals for scalar types and union types are also allowed.  In
the following example the variable <code class="code">i</code> is initialized to the value
<code class="code">2</code>, the result of incrementing the unnamed object created by
the compound literal.
</p>
<div class="example smallexample">
<pre class="example-preformatted">int i = ++(int) { 1 };
</pre></div>

<p>As a GNU extension, GCC allows initialization of objects with static storage
duration by compound literals (which is not possible in ISO C99 because
the initializer is not a constant).
It is handled as if the object were initialized only with the brace-enclosed
list if the types of the compound literal and the object match.
The elements of the compound literal must be constant.
If the object being initialized has array type of unknown size, the size is
determined by the size of the compound literal.
</p>
<div class="example smallexample">
<pre class="example-preformatted">static struct foo x = (struct foo) {1, 'a', 'b'};
static int y[] = (int []) {1, 2, 3};
static int z[] = (int [3]) {1};
</pre></div>

<p>The above lines are equivalent to the following:
</p><div class="example smallexample">
<pre class="example-preformatted">static struct foo x = {1, 'a', 'b'};
static int y[] = {1, 2, 3};
static int z[] = {1, 0, 0};
</pre></div>

<p>In C, a compound literal designates an unnamed object with static or
automatic storage duration.  In C++, a compound literal designates a
temporary object that only lives until the end of its full-expression.
As a result, well-defined C code that takes the address of a subobject
of a compound literal can be undefined in C++, so G++ rejects
the conversion of a temporary array to a pointer.  For instance, if
the array compound literal example above appeared inside a function,
any subsequent use of <code class="code">foo</code> in C++ would have undefined behavior
because the lifetime of the array ends after the declaration of <code class="code">foo</code>.
</p>
<p>As an optimization, G++ sometimes gives array compound literals longer
lifetimes: when the array either appears outside a function or has
a <code class="code">const</code>-qualified type.  If <code class="code">foo</code> and its initializer had
elements of type <code class="code">char *const</code> rather than <code class="code">char *</code>, or if
<code class="code">foo</code> were a global variable, the array would have static storage
duration.  But it is probably safest just to avoid the use of array
compound literals in C++ code.
</p>
</div>
<hr>
<div class="nav-panel">
<p>
Next: <a href="Designated-Inits.html">Designated Initializers</a>, Previous: <a href="Initializers.html">Non-Constant Initializers</a>, Up: <a href="C-Extensions.html">Extensions to the C Language Family</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Indices.html" title="Index" rel="index">Index</a>]</p>
</div>



</body>
</html>
